<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="UTF-8" />
        <meta http-equiv="X-UA-Compatible" content="IE=edge" />
        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
        <title>Document</title>
    </head>
    <body>
        <ul id="list">
            <li>百度0</li>
            <li>阿里1</li>
            <li>腾讯2</li>
        </ul>
    </body>
    <script>
        // function Person(firstName, lastName) {
        //     this.firstName = firstName
        //     this.lastName = lastName
        // }
        // const lydia = new Person('Lydia', 'Hallie')
        // const sarch = Person('Sarch', 'Smith')
        // console.log(lydia)
        // console.log(sarch)
        // const bird = {
        //     size: 'small',
        // }
        // const mouse = {
        //     name: 'Micky',
        //     small: true,
        // }
        // console.log(mouse.bird.size) //A
        // const shape = {
        //     radius: 10,
        //     diameter() {
        //         return this.radius * 2
        //     },
        //     perimeter: () => 2 * Math.PI * this.radius,
        // }
        // console.log(shape.diameter())
        // console.log(shape.perimeter())
        // for (var i = 0; i < 3; i++) {
        //     setTimeout(() => {
        //         console.log(i)
        //     }, 1)
        // }
        // for (let i = 0; i < 3; i++) {
        //     setTimeout(() => {
        //         console.log(i)
        //     }, 1)
        // }
        // const newArr = [1, 2, 3].map((n) => {
        //     if (typeof n === 'number') {
        //         return
        //     }
        //     return n * 2
        // })
        // console.log(newArr)
        // function getInfo(member, year) {
        //     member.name = 'Lydia'
        //     year = '1998'
        // }
        // const person = {
        //     name: 'Alan',
        // }
        // const birthYear = '1997'
        // getInfo(person, birthYear)
        // console.log(person, birthYear)
        // function greeting() {
        //     throw 'Hello world!' //主动抛出异常
        // }
        // function sayHi() {
        //     try {
        //         const data = greeting()
        //         console.log('It worked!', data)
        //     } catch (e) {
        //         console.log('Oh no error:', e)
        //     }
        // }
        // sayHi()
        // function Dog(name) {
        //     this.name = name
        // }
        // Dog.prototype.bark = function () {
        //     console.log(`Woof I am ${this.name}`)
        // }
        // const pet = new Dog('Mara')
        // pet.bark()
        // delete Dog.prototype.bark
        // pet.bark()
        // var b = 1
        // function outer() {
        //     var b = 2
        //     function inner() {
        //         b++
        //         var b = 3
        //         console.log(b)
        //     }
        //     inner()
        // }
        // outer()
        // function test() {
        //     var n = 1573
        //     function add() {
        //         n++
        //         console.log(n)
        //     }
        //     return { n: n, add: add }
        // }
        // var result = test() //{ n: 1573, add: add }
        // var result2 = test() //{ n: 1573, add: add }
        // // console.log(result, result2)
        // result.add()
        // result.add()
        // console.log(result.n)
        // result2.add()
        // function output(a) {
        //     console.log(a)
        // }
        // output(
        //     typeof (function () {
        //         output('Hello World!')
        //     })()
        // )
        // function fun(a, c) {}
        // delete fun
        // console.log(fun)
        // var abc = {
        //     q: 123,
        // }
        // delete abc.q
        // console.log(abc)
        // if (123) {console.log(123)}else{
        //     if (condition) {

        //     }else{

        //     }
        // }
        // var obj = {
        //     a: 'hello',
        // }
        // console.log(obj && obj.a)
        // console.log(typeof (1, 'asd'))
        // function fun() {
        //     console.log(arguments)
        // }
        // fun(1, 2, 3)
        // var myObject = {
        //     foo: 'bar',
        //     func: function () {
        //         var self = this
        //         console.log('outer func: this.foo=' + this.foo) //this指向myObject
        //         console.log('outer func: self.foo=' + self.foo) //self指向myObject
        //         ;(function () {
        //             console.log('inner func :this.foo=' + this.foo) //this指向window
        //             console.log('inner func :self.foo=' + self.foo) //self指向myObject
        //         })()
        //     },
        // }
        // myObject.func()
        // var length = 10
        // function fn() {
        //     //第一次调用this指向的是window ==10
        //     //第二次this指向的arguments ==2
        //     console.log(this.length)
        // }
        // var obj = {
        //     length: 5,
        //     method: function (fn) {
        //         fn()
        //         console.log(111, arguments[0])
        //         arguments[0]()
        //     },
        // }
        // obj.method(fn, 1)
        // ;(function (x) {
        //     return (function (y) {
        //         console.log(x)
        //     })(2)
        // })(1)
        // var a = {}
        // b = { key: 'b' }
        // c = { key: 'c' }
        // a['[Objerct Object]'] = 123 //b本来是一个对象 现在要作为一个键名那么他就会进行字符串的转换'[Objerct Object]'
        // a['[Objerct Object]'] = 456
        // console.log(a)
        // console.log(a['[Object Object]'])
        // var arr1 = 'john'.split('') //arr1: ['j','o','h','n']
        // var arr2 = arr1.reverse() //arr2: ['n','h','o','j'] //浅拷贝
        // var arr3 = 'jones'.split('') //arr3: ['j','o','n','e','s']
        // arr2.push(arr3) //arr2: ['n','h','o','j',['j','o','n','e','s']]---arr1
        // //-1 从末尾最后一个删除arr1进行了删除 浅拷贝的arr2也发生了变化 splice的返回值是删除的元素数组
        // console.log('arr1:length=' + arr1.length + 'last=' + arr1.splice(-1))
        // console.log('arr2:length=' + arr2.length + 'last=' + arr2.splice(-1)) //4   ['j']
        // var d = {}
        // var b = ['car', 'house']
        // b.forEach(function (k) {
        //     d[k] = undefined
        // })
        // console.log(d)
        //当for循环执行到不满条件是终止
        // for (var i = 0; i < 5; i++) {
        //     var btn = document.createElement('button')
        //     btn.appendChild(document.createTextNode('按钮' + i))
        //     btn.addEventListener('click', function () {
        //         console.log(i)
        //     })
        //     document.body.appendChild(btn)
        // }
        //结果一致
        // function sum() {
        //     let res = [...arguments]
        //     //  ... 展开运算符 意思arguments内的所有值，arguments获取传过来的所有参数
        //     if (arguments.length > 1) {
        //         return res
        //     } else {
        //         return function (n) {
        //             return [...res, n]
        //         }
        //     }
        // }
        // console.log(sum(2, 3))
        // console.log(sum(2)(3))
        // var x = 10
        // var foo = {
        //     x: 90,
        //     getX: function () {
        //         return this.x //当前对象是foo
        //     },
        // }
        // console.log(foo.getX())
        // var xGetter = foo.getX //赋值的函数原型
        // console.log(xGetter()) //调用函数 this指向window
        // var obj = {
        //     a: 1,
        //     b: 2,
        // }
        // // Object.setPrototypeOf(obj, { a: 3 }) //给Obj对象设置属性
        // Object.defineProperty(obj, 'd', { value: 4, enumerable: false })//是否枚举类型，是否循环遍历是可拿到
        // console.log(Object.setPrototypeOf(obj, { a: 3 })) //方法设置一个指定的对象的原型（即，内部 [[Prototype]] 属性）到另一个对象或 null。
        // for (let prop in obj) {
        //     console.log(prop)
        // }
        // function F() {
        //     this.a = 1
        // }
        // var obj = new F()
        // // let data = {} //对象只有 __proto__属性没有prototype属性，函数才有

        // console.log(obj.prototype) //undefinde
        // console.log('b' + 'a' + +(+'a') + 'a')
        // var x = 1
        // if (function f() {}) {
        //     x = x + typeof f
        // }
        // console.log(x)
        // console.log(Boolean(false))
        // console.log(Boolean('0'))
        // console.log(Boolean(''))
        // console.log(Boolean(NaN)) //false
        // console.log(
        //     (function () {
        //         return typeof arguments //object 可迭代的对象
        //     })()
        // )
        // function foo1() {
        //     return {
        //         bar: 'hello',
        //     }
        // }
        // function foo2() {
        //     return {
        //         bar: 'hello',
        //     }
        // }
        // console.log(foo1())
        // console.log(foo2())
        // Object.prototype.bar = 1 //可迭代对象属性 意思就是循环的时候可以循环到这个属性
        // var foo = {
        //     moo: 2,
        // }
        // console.log(foo)
        // for (var i in foo) {
        //     console.log(i)
        // }
        // Object.prototype.bar = 1
        // var foo = {
        //     goo: undefined,
        // }
        // console.log(foo.bar)
        // console.log('bar' in foo)
        // console.log(foo.hasOwnProperty('bar'))
        // console.log(foo.hasOwnProperty('goo'))

        // var x = 10
        // function fn() {
        //     console.log(x)
        // }
        // function show(f) {
        //     var x = 20
        //     fn()
        // }
        // show(fn)
        // var obj = { n: 1 }
        // function fn2(a) {
        //     a.n = 2
        // }
        // fn2(obj)
        // console.log(obj.n) //参数传参 是浅拷贝
        // console.log(typeof a)
        // function a() {}
        // var a
        // console.log(typeof a)
        // console.log(c)
        // function c(a) {
        //     console.log(a) // 首先找的是函数名 其次形参，找在代码块的声明变量
        //     var a = 3
        //     function a() {}
        // }
        // c(2)
        // 28.
        // https://blog.csdn.net/weixin_44179269/article/details/113915734
        // var a = { n: 1 }
        // var b = a //{n:1}
        // a.x = a = { k: 8 } // 赋值a的时候是直接覆盖掉整个a变量实际值，而赋值a.x的时候是引用地址里面的值
        // console.log(a, b)
        // console.log(a.n, b.n) // 2,1
        // console.log(a.x, b.x)
        // var a = 666
        // console.log(++a)
        // console.log(a++)
        // console.log(a)
        // console.log(1 + '2' + '2')
        // console.log(1 + +'2' + '2')
        // console.log(+'1' - +'1' + '2')
        // console.log('A' - 'B' + '2')
        // console.log('A' - 'B' + 2)
        // console.log(false.toString()) //字符串false
        // console.log([1, 2, 3].toString()) // 1,2,3
        // console.log(1.toString());
        // console.log((5.0).toString())
        // 24
        // function A() {}
        // A.prototype.n = 1
        // A.prototype.m = 123
        // var b = new A()
        // console.log(b.n, b.m)
        // A.prototype = {
        //     n: 2,
        //     m: 3,
        // }
        // var c = new A()
        // console.log(b.n, b.m)
        // console.log(c.n, c.m)
        //23 instanceof 判断原型链上是否存在这个值
        // function f() {
        //     return f
        // }
        // console.log(new f() instanceof f) //检查我自己的原型链上有没有我自己
        // 22 undefinde 原因没有对应的key
        // var a = (function (mm) {
        //     return typeof mm.bar
        // })({ foo: { bar: 1 } })
        // console.log(a)
        // 21 原因： a 使用了var 声明  b没有声明所以
        // 打印a是undefined,b只有在执行函数 赋值操作的时候会声明所有打印b是not defined
        // ;(function () {
        //     var a = (b = 3)
        // })()
        // console.log(typeof a === 'undefined') //true  声明了 没有赋值
        // console.log(typeof b === 'undefined') //false 没有声明 not defined

        // // 18
        // var name = 'kaivon'
        // var object = {
        //     name: 'chen',
        //     getNameFunc: function () {
        //         var that = this
        //         return function () {
        //             return that.name
        //         }
        //     },
        // }
        // console.log(object.getNameFunc()())
        // 17
        // var val = 1
        // var obj = {
        //     val: 2,
        //     del: function () {
        //         console.log(this)
        //         this.val *= 2
        //         console.log(this.val)
        //     },
        // }
        // obj.del()
        // 16
        /* if (!('a' in window)) {
                    var a = 1
                }
                console.log(a) */
        // 15题
        /*       var a = 10
                function test() {
                    a = 100
                    console.log(a)
                    console.log(this.a)
                    var a
                    console.log(a)
                }
                test() */
        // 14题
        // var name = 'kaivan'
        // ;(function () {
        //     if (typeof name === 'undefined') {
        //         var name = 'chen'
        //         console.log(name)
        //     } else {
        //         console.log(name)
        //     }
        // })()
        /*   12题：
                var list = document.getElementById('list')
                var lis = list.querySelectorAll('li')
                console.log(lis)
                list.replaceChild(lis[2], lis[1])
                console.log(lis)
                list.insertBefore(lis[1], list.children[2]) */
        /* // 11
                //解构赋值 结果 1,2,3 原因没有值的时候使用默认值
                var [a = 3, b = a, c = 3] = [1, 2, undefined]
                console.log(a, b, c) */
        /*   // 10 计算两个数组的差集
                let arr1 = [1, 2, 3, 4, 5]
                let arr2 = [4, 5, 6, 7, 8]
                let tmp = [...arr1, ...arr2]
                let res = tmp.filter((item) => {
                    return !arr1.includes(item) || !arr2.includes(item)
                })
                console.log(res) */
        /* // 9.结果：a:undefined ,b is not defined
                //原因 a使用的是var声明，可以变量提升 没有局部作用域，
                // b使用的是let声明，没有变量提升，有局部作用域
                //代码执行之后 if false 不会执行代码 但页面打开时声明都生效，赋值是在执行if时
                if (false) {
                    var a = 1
                    let b = 2
                }
                console.log(a)
                console.log(b) */
        /*  // 8.
                // function F() {
                //     this.a = 1
                // }
                // var obj = new F()
                // console.log(obj.prototype) */
        /*  // 6. 结果 123 原因：因为传参123，
                fn(123)
                var a = 456
                function fn(b) {
                    console.log(a)
                } */

        /*     // 5.以下代码运行后，在控制台里打印输出的内容为
                //结果：2 undefined 原因：2传给f2的x,y = 2 打印结果就是2
                // undefined 因为f1调用的时候没有传参，所有x就是undefined,y也没有传参就使用默认值x，x是undefined，所以y也是undefined
                let x = 1
                function f1(x, y = x) {
                    console.log(y)
                }
                function f2(y = x) {
                    let x = 0
                    console.log(y)
                }
                f2(2)
                f1() */
        /*  // 4.请你写出代码，计算两个数组的交集
                let arr1 = [1, 2, 3, 4, 5, 5, 3, 2]
                let arr2 = [4, 5, 6, 7, 7, 8]

                const set_intersection = (set1, set2) => {
                    //如果参数1数组 的长度 大于 参数2数组 的长度
                    if (set1.size > set2.size) {
                        //交换参数1数组 和 参数2数组
                        return set_intersection(set2, set1)
                    }
                    //创建一个空数组
                    const intersection = new Set()
                    //遍历迭代器 最小的数组
                    for (const num of set1) {
                        //判断数组2中是否包含数组1中的元素
                        if (set2.has(num)) {
                            //如果包含就添加到空数组中
                            intersection.add(num)
                        }
                    }
                    //返回结果 ...扩展运算符
                    return [...intersection]
                }

                var intersection = function (nums1, nums2) {
                    const set1 = new Set(nums1) //去重
                    const set2 = new Set(nums2)
                    return set_intersection(set1, set2)
                }
                console.log(intersection(arr1, arr2)) */
        /*  // 3. 结果：9 原因：new Set 去除重复的值之后的大小
                        var a = [
                            1,
                            2,
                            2,
                            3,
                            [1, 2, 3],
                            3,
                            5,
                            [1, 2, 3],
                            6,
                            {
                                name: '张三',
                            },
                            6,
                            6,
                            undefined,
                            {
                                name: '张三',
                            },
                            'A',
                            undefined,
                            true,
                            null,
                        ]
                        var s = new Set(a)
                        console.log(s.size, s) */
        /*    //2.结果：Cannot access 'a' before initialization
                        //原因：局部作用域内声明有A但还没进行赋值就开始使用
                        var a = 1
                        if (true) {
                            console.log(a)
                            let a = 2
                        } */
        /* // 1. 结果：undefined 原因：没有定义
                        var foo = function bar() {}
                        console.log(typeof bar) */
    </script>
</html>
